/**
 * Level操作接口
 */
export interface ILevelOpt {
    /** 类型 put del  */
    type: string;
    /** 关键字 */
    key: string | number | any;
    /** 值 */
    value: string | any;
}

/**
 * Level数据库操作类
 */
export class LevelOpt implements ILevelOpt {
    /** 操作类型 put del */
    public type: string = 'put';
    /** 关键字 */
    public key: string | number | any = "";
    /** 值 */
    public value: string | any = "";

    /**
     * 构造函数
     * @param type 操作类型 (值为'put'或'del')
     * @param key 关键字
     * @param value 值
     */
    constructor(type: string = 'put',key: string | number | any, value: string | any ) {
        this.type = type;
        this.key = key;
        this.value = value;
    }
}

/** 
 * 管理level数据库类 
 * @see key一般为字符buffer类型，如果希望可以为number型，那么需要通过buffer进行转换后再插入数据
 * */
export class ManageLevel {
    /** level数据库类 */
    private _db: any | Object = {};
    private levelup = require('levelup')
    private leveldown = require('leveldown')

    constructor() {
    }

	/**
	 * 数据库打开
	 * @returns true 打开成功 false 打开失败
	 */
    Open(filename: string) {
        return new Promise((resovlve, reject) => {
            try {
                this._db = this.levelup(this.leveldown(filename));
                resovlve(true);
            } catch (err) {
                reject(false);
            }
        });
    }

    /**
     * 插入键值
     * @param key 关键字
     * @param value 值
     */
    Put(key: any, value: any) {
        return this._db.put(key, value);
    }

    /**
     * 获取键值
     * @param key 关键字
     */
    Get(key: any) {
        return this._db.get(key);
    }

    /**
     * 删除键值
     * @param key 
     */
    Del(key: any) {
        return this._db.del(key);
    }

    /**
     * 批量操作
     * @param opts 操作数组
     */
    Batch(opts: Array<ILevelOpt>) {
        return new Promise((resovlve, reject) => {
            try {
                this._db.batch(opts, (err: any) => {
                    if (err) {
                        reject(false);
                    } else {
                        resovlve(true);
                    }
                });
            }
            catch (err) {
                reject(false);
            }
        });
    }

    /**
     * 查询
     * @param gtvalue 大于某值
     * @param ltvalue 小于某值
     * @param gtevalue 大于等于某值
     * @param ltevalue 小于等于某值
     * @param limit 显示记录数
     * @param isreverse 是否逆序
     * @returns 返回对象数组
     */
    Find(
        gtvalue?: any, ltvalue?: any, gtevalue?: any, ltevalue?: any,
        limit?: any, isreverse: boolean = true) {
        return new Promise((resovlve, reject) => {
            try {
                let opt: any = {};
                // if (!showkeys) {
                //     opt.keys = showkeys;
                // }
                // if (!showvalues) {
                //     opt.values = showvalues;
                // }

                if (gtvalue) {
                    opt.gt = gtvalue;
                }

                if (ltvalue) {
                    opt.lt = ltvalue;
                }

                if (gtevalue) {
                    opt.gte = gtevalue;
                }

                if (ltevalue) {
                    opt.lte = ltevalue;
                }

                if (limit) {
                    opt.limit = limit;
                }

                if (!isreverse) {
                    opt.isreverse = isreverse;
                }

                let _returndata: Array<any> = [];
                console.log(opt);
                this._db.createReadStream(opt)
                    .on('data', function (data: any) {
                        console.log('d',data);
                        _returndata.push(data);
                    })
                    .on('error', function (err: any) {
                        reject([]);
                    })
                    .on('close', function () {
                        //resovlve(_returndata);
                    })
                    .on('end', function (err:any) {
                        
                        if(err) {
                            console.log('err',err);
                            reject([]);
                        }
                        resovlve(_returndata);
                    })
            }
            catch(err){
                console.log('err2',err);
                reject([]);
            }
        });
    }

	/** 关闭数据库
	 * @returns true 关闭成功 false 关闭失败
	 */
    Close() {
        return new Promise((resovlve, reject) => {
            try {
                this._db.close();
                resovlve(true);
            } catch (err) {
                reject(false);
            }
        });
    }
}
